Preparing a Python Project Portfolio with Git and GitHub

Course: Python Training

Topic: Preparing a Python Project Portfolio with Git and GitHub

Course Link: Python Training Course at JustAcademy

Demo Link: Register for a Free Course Demo

Official Website: JustAcademy

1. Introduction to a Python Project Portfolio

A Python project portfolio is a collection of programming projects that demonstrates your practical knowledge, problem-solving ability, coding style, and experience building applications. It helps recruiters, interviewers, clients, and collaborators understand what you can create with Python.

Learning Python syntax is important, but employers also want to see how you apply that knowledge to real-world problems. A well-organized portfolio provides evidence of your ability to write code, structure projects, handle errors, work with data, test applications, and explain technical decisions.

Git and GitHub are essential tools for maintaining and presenting a professional portfolio. Git tracks changes to your source code, while GitHub hosts Git repositories online and makes your projects easy to review and share.

Why Build a Python Portfolio?

• Demonstrates practical Python programming skills.
• Provides evidence of project experience for a resume.
• Shows familiarity with industry-standard development tools.
• Helps prepare for technical interviews and coding assessments.
• Allows other developers to review, use, or contribute to your projects.
• Creates a record of your learning progress and development history.

2. Learning Objectives

After completing this topic, learners should be able to:

• Choose suitable Python projects for a professional portfolio.
• Organize project files using a clear directory structure.
• Understand the difference between Git and GitHub.
• Initialize repositories, stage files, commit changes, and create branches.
• Create and manage GitHub repositories.
• Write meaningful README documentation.
• Use virtual environments and dependency files.
• Protect sensitive information using environment variables and Git ignore rules.
• Use testing and basic automation to improve project quality.
• Present projects effectively on GitHub and in a resume.

3. Understanding Git and GitHub

3.1 What Is Git?

Git is a distributed version control system used to track changes in files. It records project history through commits, allowing developers to inspect previous versions, compare changes, and collaborate without losing track of their work.

Git works locally on your computer. You can initialize a repository, commit changes, create branches, and review project history without an internet connection.

3.2 What Is GitHub?

GitHub is an online platform for hosting Git repositories. It provides tools for sharing code, reviewing changes, tracking issues, documenting projects, and collaborating with other developers.

A GitHub repository can contain source code, documentation, tests, configuration files, project screenshots, and instructions for running an application.

3.3 Git vs. GitHub

4. Choosing Projects for Your Portfolio

Select projects that demonstrate different skills instead of publishing many nearly identical exercises. Start with a small project, then gradually introduce more complex features such as databases, APIs, testing, and deployment.

How to Select a Strong Project

• Choose a problem that can be explained clearly.
• Make sure the project matches your current skill level.
• Include enough functionality to demonstrate meaningful problem-solving.
• Identify what makes the project useful or different.
• Finish and document a small project before starting several new ones.
• Never claim that a project has features, tests, or deployment that it does not actually have.

5. Planning a Portfolio Project

Before writing code, define the purpose, expected behavior, inputs, outputs, features, and limitations of the application. A brief plan prevents unnecessary complexity and helps you explain your design during interviews.

Example: Expense Tracker

Objective: Build a Python application that records expenses and summarizes spending.

Core features:

• Add an expense with amount, category, date, and description.
• Validate user input and reject invalid amounts.
• Store expense records in a CSV file or SQLite database.
• Display all recorded expenses.
• Calculate total spending and category-wise totals.
• Filter expenses by date or category.
• Handle missing files and database errors gracefully.
• Include automated tests for important calculations and validation rules.

Possible future enhancements: Add charts, monthly budgets, CSV export, a web interface, or user authentication if appropriate for the project.

6. Setting Up Python and Git

6.1 Verify Python Installation

Open a terminal or command prompt and check whether Python is installed:

python --version

On systems where Python is accessed through the python3 command, use:

python3 --version

6.2 Verify Git Installation

git --version

If Git is unavailable, install it using the official Git installation instructions for your operating system. You can use a code editor such as Visual Studio Code or another editor of your choice.

6.3 Configure Your Git Identity

Set the name and email that Git should associate with your commits:

git config --global user.name "Your Name"
git config --global user.email "[email protected]"

Use an appropriate email address or a GitHub-provided private commit email if you prefer not to expose your personal email address publicly.

Check your configuration with:

git config --global --list

7. Creating a Python Project Structure

A clean directory structure makes your project easier to understand, maintain, test, and extend. The exact structure depends on the application, but files should have clear names and responsibilities.

expense-tracker/
├── README.md
├── .gitignore
├── requirements.txt
├── .env.example
├── src/
│   └── expense_tracker/
│       ├── __init__.py
│       └── main.py
├── tests/
│   └── test_expenses.py
└── data/
    └── .gitkeep

Purpose of the main files:

• README.md: Explains the project, features, installation, usage, and examples.
• .gitignore: Lists files and folders Git should ignore.
• requirements.txt: Records external Python dependencies.
• .env.example: Documents the names of required environment variables without real secrets.
• src/: Contains the application source code.
• tests/: Contains automated tests.
• data/: May contain local data files; avoid committing private or sensitive data.

Do not add every possible folder to a small project. Use a structure that fits the application's actual needs.

8. Creating a Virtual Environment

A virtual environment isolates a project's installed Python packages from other projects. This helps avoid dependency conflicts and makes the project easier to reproduce on another computer.

8.1 Create the Environment

python -m venv .venv

8.2 Activate It

Windows Command Prompt:

.venv\Scripts\activate

Windows PowerShell:

.\.venv\Scripts\Activate.ps1

macOS or Linux:

source .venv/bin/activate

After activation, install the packages required by the project. Do not normally upload the virtual environment folder to GitHub; another developer can recreate it from the dependency information.

9. Writing a Useful .gitignore File

The .gitignore file prevents unnecessary files from being added to version control. Python projects often contain compiled files, virtual environments, local configuration, and generated test output that should not be committed.

# Python cache files
__pycache__/
*.py[cod]

# Virtual environments
.venv/
venv/

# Environment variables and local secrets
.env
.env.*

# Allow a safe example configuration file
!.env.example

# Test and coverage output
.pytest_cache/
.coverage
htmlcov/

# Editor and operating-system files
.vscode/
.DS_Store
Thumbs.db

Adapt these patterns to your project. Do not ignore files that are necessary to run the application, such as source code, tests, README documentation, or a legitimate dependency file.

Important: Adding a file to .gitignore does not remove it from Git if it has already been tracked. If a secret was committed, removing it from the latest version is not sufficient: revoke or rotate the exposed credential and take appropriate steps to remove it from repository history when necessary.

10. Initializing a Git Repository

Open a terminal inside the project directory and run:

git init
git status

git init creates a local Git repository. git status shows which files are untracked, modified, staged, or committed.

10.1 Stage Files

git add README.md
git add src/ tests/ .gitignore requirements.txt

Staging selects the changes that will be included in the next commit. Review the staged changes before committing. For a new project, you can stage all appropriate files with git add ., but inspect the status first to avoid accidentally adding secrets, generated files, or private data.

10.2 Create Your First Commit

git commit -m "Initial expense tracker project"

A commit records a snapshot of the staged changes and adds a message to the project history. Write commit messages that explain the change rather than using vague descriptions such as “update” or “changes”.

10.3 Review Project History

git log --oneline

This command displays a compact view of recent commits. You can use it to understand the project's development history and identify when a feature or fix was introduced.

11. Creating a GitHub Repository

After preparing the local repository, create an online repository on GitHub.

1. Sign in to your GitHub account.
2. Select the option to create a new repository.
3. Choose a clear repository name, such as python-expense-tracker.
4. Write a short description of the project.
5. Choose public or private visibility according to your needs.
6. If your local project already contains a README and initial commit, avoid automatically adding conflicting initial files when creating the remote repository.
7. Create the repository and copy its remote URL.

For a portfolio intended for recruiters, a public repository makes it easier for others to inspect your code. Confirm that the repository contains no credentials, personal information, private datasets, or content you do not have permission to publish.

12. Connecting the Local Repository to GitHub

To connect your existing local repository to the remote repository, use the URL provided by GitHub:

git remote add origin https://github.com/YOUR-USERNAME/python-expense-tracker.git
git branch -M main
git push -u origin main

Replace YOUR-USERNAME with your GitHub username and use the actual repository URL. The command git remote add origin defines the remote repository, git branch -M main names the current branch main, and git push -u origin main uploads the branch and sets its upstream tracking relationship.

Check the remote configuration with:

git remote -v

GitHub authentication may require a browser-based sign-in, a supported credential manager, SSH, or a personal access token where applicable. Do not place access tokens or passwords directly in source code or repository URLs.

13. Making and Publishing Changes

As you develop the project, use a repeatable workflow to keep your repository history organized.

# Check current changes
git status

# Review the difference in tracked files
git diff

# Stage a specific file
git add src/expense_tracker/main.py

# Commit the change
git commit -m "Add expense input validation"

# Push commits to GitHub
git push

For staged changes, use git diff --staged to inspect exactly what will be included in the next commit. This is especially useful for checking whether a credential, unrelated change, or generated file has accidentally been staged.

Suggested Development Workflow

1. Choose one small feature or bug fix.
2. Write or update the code.
3. Run the application and relevant tests.
4. Review the changes using git diff.
5. Stage only the intended files.
6. Create a descriptive commit.
7. Push the commit to GitHub.
8. Update the README if the user-facing behavior or setup instructions have changed.

14. Using Branches for New Features

Branches allow you to develop a feature or fix separately from the main branch. This keeps work organized and supports review before changes are merged.

# Create and switch to a feature branch
git switch -c feature/monthly-summary

# Work on the feature, then stage and commit it
git add src/ tests/
git commit -m "Add monthly expense summary"

# Push the branch to GitHub
git push -u origin feature/monthly-summary

When the feature is ready, open a pull request on GitHub if you want to review the changes before merging. After review and testing, merge the branch according to your workflow. For a solo learning project, branches are also useful for practicing safe experimentation and understanding Git history.

15. Writing a Professional README.md

The README is often the first document a visitor sees on GitHub. It should help a new user understand the project's purpose and get it running without needing to guess the setup steps.

Recommended README Sections

• Project title: Use a clear, recognizable name.
• Overview: Describe the problem the project solves.
• Features: List implemented capabilities.
• Technology stack: Mention Python version, libraries, and storage technologies.
• Installation: Explain how to clone the repository and set up the environment.
• Configuration: Describe required environment variables using safe placeholder examples.
• Usage: Provide commands, examples, screenshots, or sample outputs.
• Testing: Explain how to run the tests.
• Project structure: Describe important folders and files.
• Limitations and future improvements: Explain what remains to be implemented.
• License: Include a suitable license if you want others to use or modify the project under its terms.

Example README Content

# Python Expense Tracker

A Python application for recording expenses and reviewing spending totals.

## Features
- Add and list expense records
- Validate expense amounts
- Calculate total spending
- Filter records by category

## Requirements
- Python 3
- Dependencies listed in requirements.txt

## Setup
1. Clone this repository.
2. Create and activate a virtual environment.
3. Install the required dependencies.
4. Follow the configuration instructions below.

## Run
python -m expense_tracker

## Tests
python -m unittest discover -s tests

## Future Improvements
- Monthly spending reports
- CSV export
- Optional charts

This is a sample template, not a guarantee that the commands will work unchanged for every directory structure. Update the instructions to match your actual application and test them in a clean environment.

16. Managing Dependencies with requirements.txt

Python projects often rely on third-party packages. Recording dependencies helps another developer recreate the environment required to run your application.

16.1 Create the File

If your project uses external packages, add the appropriate packages and version constraints to requirements.txt. For example:

requests>=2.31,<3
python-dotenv>=1.0,<2

These example constraints are illustrative; select versions compatible with your project and verify them in your environment.

16.2 Install Dependencies

python -m pip install -r requirements.txt

For a project that uses only the Python standard library, a dependency file may be unnecessary. Avoid adding unused packages merely to make the project look more advanced.

17. Protecting Secrets and Private Data

Portfolio repositories should be safe to share. API keys, passwords, database credentials, private certificates, and personal information must not be published in source code or configuration files.

17.1 Use Environment Variables

For example, an application can read a configuration value from the environment:

import os

api_key = os.getenv("WEATHER_API_KEY")

if not api_key:
    raise RuntimeError("WEATHER_API_KEY is not configured")

Set the environment variable through your operating system, development environment, or deployment platform. If you use a local .env file, keep it out of Git and consider using a library such as python-dotenv when appropriate.

17.2 Provide a Safe Example File

# .env.example
WEATHER_API_KEY=replace_with_your_own_key

Explain in the README how to copy this example into a local configuration file and provide real values securely. The example file must contain placeholders, not real secrets.

17.3 Check Before Publishing

• Inspect staged changes before committing.
• Exclude virtual environments and private local files.
• Use synthetic or public datasets when possible.
• Remove personally identifiable information from sample output.
• Do not upload database dumps containing real customer information.
• If a secret is exposed, revoke or rotate it immediately; deleting the visible line alone may not remove it from commit history.

18. Adding Tests to Your Portfolio Project

Automated tests help demonstrate that your code behaves as expected. They also make future changes safer by detecting regressions.

Suppose the application has a function that adds a new expense to a total:

def add_expense_total(current_total, amount):
    if amount <= 0:
        raise ValueError("Amount must be greater than zero")
    return current_total + amount

A basic test using Python's built-in unittest module could look like this:

import unittest
from expense_tracker import add_expense_total

class TestExpenseTotal(unittest.TestCase):
    def test_adds_positive_amount(self):
        self.assertEqual(add_expense_total(100, 25), 125)

    def test_rejects_non_positive_amount(self):
        with self.assertRaises(ValueError):
            add_expense_total(100, 0)

if __name__ == "__main__":
    unittest.main()

The import path depends on how the application package is organized. Adjust it to match the actual source code and run the test to verify that the setup works.

What Should You Test?

• Valid and invalid user input.
• Calculations and business rules.
• Empty files, missing records, or unavailable data.
• Database operations and error handling.
• API failures, timeouts, and malformed responses where applicable.
• Important boundary conditions, such as zero, negative values, and empty strings.

19. Improving Code Quality

Readable, maintainable code is more valuable than code that is merely long or complicated. A portfolio should show that you can organize logic into understandable components and follow consistent conventions.

• Use descriptive variable, function, and class names.
• Follow standard Python naming conventions, such as snake_case for functions and variables.
• Break large functions into smaller, focused functions.
• Handle expected errors explicitly and provide useful messages.
• Remove unused imports, unreachable code, and debugging statements.
• Use docstrings for public functions and complex behavior.
• Keep formatting consistent throughout the project.
• Use a formatter or linter, such as Black or Ruff, when appropriate.
• Keep business logic separate from user-interface or input/output code when that separation improves clarity.

20. Adding GitHub Actions for Automated Checks

GitHub Actions can automatically run tests or quality checks when code is pushed or a pull request is opened. A basic continuous integration workflow helps demonstrate that you understand repeatable testing practices.

For example, create a workflow file at .github/workflows/tests.yml:

name: Python Tests

on:
  push:
  pull_request:

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Check out repository
        uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: "3.12"

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          if [ -f requirements.txt ]; then
            python -m pip install -r requirements.txt
          fi

      - name: Run tests
        run: python -m unittest discover -s tests

This workflow is an example and may need adjustments for the project's supported Python versions, dependencies, test framework, or package layout. GitHub Actions configuration also depends on the current platform and workflow requirements, so review the official documentation before relying on it in a production project.

21. Creating a Portfolio Profile on GitHub

Your GitHub profile is the central place where recruiters and other developers can explore your work. Make it easy for visitors to find your strongest projects.

Profile Improvements

• Use a professional username and a clear profile description.
• Add relevant skills, a portfolio website, or professional links if available.
• Pin your strongest repositories rather than every practice exercise.
• Keep project names and descriptions concise and meaningful.
• Ensure each featured repository has a useful README.
• Archive or clearly label outdated experiments.
• Make sure public repositories are safe to view and easy to run.
• Use contribution history honestly; do not manufacture activity or misrepresent work completed by others.

22. Writing Good Commit Messages

A commit message should explain the change in a short, meaningful way. Consistent messages make the project's history easier to read.

Small, focused commits make it easier to understand which change introduced a feature or fixed a bug. Avoid including unrelated work in a single commit whenever possible.

23. Common Git and GitHub Problems

Useful Git Commands for Troubleshooting

git status
git diff
git diff --staged
git log --oneline
git remote -v
git branch
git fetch origin

Before running destructive commands such as a hard reset or force push, understand their effects. They can discard local work or overwrite remote history. Preserve important work and coordinate with collaborators before rewriting shared history.

24. Example Portfolio Project: Python Expense Tracker

This project brings together Python programming, file or database storage, testing, documentation, and GitHub publishing.

Step 1: Define the Requirements

Write down the expected inputs, outputs, supported features, and validation rules. For example, expense amounts must be positive, categories must be non-empty, and totals should be calculated accurately.

Step 2: Build the Core Logic

Create functions for adding expenses, validating values, calculating totals, filtering records, and displaying summaries. Keep each function focused on one responsibility.

Step 3: Add Persistence

Start with CSV or JSON for a simple local application, or use SQLite when relational queries and structured data management are useful. Handle missing files and invalid data safely.

Step 4: Test the Application

Write tests for normal cases and edge cases. Check that invalid amounts are rejected, totals are correct, and empty datasets do not cause unexpected failures.

Step 5: Prepare the Repository

Create a suitable project structure, add a .gitignore, document dependencies, and confirm that no private data or secrets are present.

Step 6: Publish the Project

Initialize Git, commit the source code, create a GitHub repository, connect the remote, and push the main branch. Make sure the repository can be accessed by the intended audience.

Step 7: Complete the Documentation

Add installation instructions, examples, screenshots where useful, testing commands, limitations, and possible future enhancements to the README.

Step 8: Review the Finished Portfolio Entry

Clone the repository into a separate folder or use another clean environment, follow the README, install dependencies, run the application, and execute the tests. Fix missing instructions or configuration before presenting it as a completed project.

25. Showcasing Projects on a Resume

Project descriptions should focus on the problem, the features implemented, the tools used, and the outcome. Be specific and honest about your contribution.

Example Resume Entry

Python Expense Tracker | Python, SQLite, Git, GitHub

• Developed an expense tracking application with input validation and category-wise summaries.
• Implemented local data storage and reusable functions for expense calculations.
• Added automated tests for core validation and calculation behavior.
• Documented setup and usage instructions and maintained the source code in a GitHub repository.

Only include technologies and features that you actually implemented. If you measured performance improvements or user impact, include verifiable figures rather than invented metrics.

26. Preparing to Discuss Projects in Interviews

Interviewers may ask you to explain your project decisions, code structure, testing approach, and use of Git. Practice describing your project in a clear sequence.

1. Problem: What issue does the project solve?
2. Approach: How did you break the problem into smaller parts?
3. Technology: Why did you choose Python, a particular library, or a database?
4. Implementation: What are the main components and how do they work?
5. Challenges: What bugs or design problems did you encounter?
6. Testing: How did you verify that the application works?
7. Version control: How did you use commits, branches, and GitHub?
8. Improvements: What would you change or add next?

A strong explanation focuses on the decisions you made and what you learned. Be prepared to open your repository and walk through an important function or test.

27. Best Practices for a Professional Python Portfolio

• Prefer a few complete, well-documented projects over many unfinished repositories.
• Keep source code readable and organize it around clear responsibilities.
• Write a README that can be followed by someone unfamiliar with the project.
• Record dependencies and explain environment configuration.
• Use tests for important behavior and edge cases.
• Use Git commits to maintain a useful development history.
• Keep credentials, personal data, and proprietary information out of public repositories.
• Use realistic sample data that you have permission to share.
• Document known limitations instead of hiding them.
• Review repository access, branch settings, and licenses when relevant.
• Keep the project runnable and update instructions when setup changes.
• Be prepared to explain every major feature you list on your resume.

28. Practical Exercises

1. Create a new Python project and organize it using a clear folder structure.
2. Initialize Git and make an initial commit containing the source code and README.
3. Create a GitHub repository and push your local project to it.
4. Write a .gitignore file that excludes virtual environments, caches, and local secrets.
5. Create a virtual environment and document the dependency installation steps.
6. Write at least three tests for important project functions.
7. Create a feature branch, implement a small improvement, and merge it after testing.
8. Improve the README with usage examples and a project structure description.
9. Review the repository for accidental secrets or personal information.
10. Write a short resume entry that accurately summarizes the project and your contribution.

29. Mini Project Assignment

Assignment: Develop a Python application and publish it as a professional GitHub repository.

Minimum Requirements

• Use Python functions and appropriate data structures.
• Implement at least three meaningful features.
• Validate user input and handle expected errors.
• Save data to a file or database if the application requires persistence.
• Use Git to track the project history.
• Publish the source code to GitHub.
• Include a README with setup and usage instructions.
• Include a suitable .gitignore file.
• Add automated tests for important functionality.
• Keep credentials and private data out of the repository.

Evaluation Criteria

30. Interview Questions and Answers

Q1. What is a Python project portfolio?

Answer: It is a collection of Python projects that demonstrates practical programming skills, problem-solving ability, code organization, and experience with development tools.

Q2. What is Git?

Answer: Git is a distributed version control system that tracks changes, stores commit history, and supports branching and merging.

Q3. What is GitHub?

Answer: GitHub is an online platform for hosting Git repositories and supporting collaboration, documentation, issue tracking, and code review.

Q4. What is the difference between Git and GitHub?

Answer: Git manages version history, usually on a local computer, while GitHub hosts repositories online and provides collaboration features.

Q5. What is a Git repository?

Answer: A repository is a project location managed by Git. It contains tracked files and the history of committed changes.

Q6. What is a commit?

Answer: A commit is a recorded snapshot of staged changes, accompanied by metadata and a message describing the changes.

Q7. What is the purpose of git add?

Answer: The git add command stages changes for inclusion in the next commit.

Q8. What is the purpose of git push?

Answer: The git push command sends local commits to a configured remote repository.

Q9. Why use branches?

Answer: Branches allow developers to work on features or fixes separately and review changes before merging them into the main development branch.

Q10. Why is a README important?

Answer: A README explains the project's purpose, features, installation, configuration, usage, and testing instructions so other people can understand and run it.

Q11. Why should a virtual environment be used?

Answer: A virtual environment isolates project dependencies and reduces conflicts between packages used by different projects.

Q12. What is the purpose of .gitignore?

Answer: It specifies untracked files and patterns Git should ignore, such as cache files, virtual environments, and local configuration files.

Q13. Does .gitignore remove a file that Git already tracks?

Answer: No. A file already tracked by Git remains tracked until it is removed from the index or otherwise handled. Sensitive information already committed may also remain in history.

Q14. How can you keep API keys out of a repository?

Answer: Store credentials in environment variables or a secure secret-management system, exclude local secret files from Git, and use placeholder values in example configuration files.

Q15. Why are automated tests useful in a portfolio?

Answer: Tests demonstrate that important behavior has been verified and help detect regressions when code changes.

Q16. What should you do if a Git merge conflict occurs?

Answer: Inspect the conflicting sections, edit the file to retain the intended changes, remove conflict markers, run relevant tests, and stage and commit the resolved file.

Q17. What should a recruiter see in a strong Python repository?

Answer: A clear purpose, readable code, useful README documentation, reproducible setup instructions, relevant tests, meaningful version history, and no exposed secrets.

Q18. How do you explain a project during an interview?

Answer: Explain the problem, your approach, the technology choices, the main features, the challenges, how you tested it, and what you would improve next.

31. Quick Revision Checklist

• Understand the roles of Python, Git, and GitHub.
• Choose a useful project and define its requirements.
• Organize source code, tests, and documentation clearly.
• Create and activate a virtual environment when appropriate.
• Record dependencies and configure .gitignore.
• Initialize Git and review the files before staging.
• Create meaningful commits and inspect project history.
• Connect the local repository to GitHub and push changes.
• Use branches to organize features and fixes.
• Write and test the README installation instructions.
• Add automated tests for important behavior.
• Protect secrets and private information.
• Keep the repository accurate, accessible, and easy to review.
• Prepare a clear project explanation for interviews and resume discussions.

32. Conclusion

Preparing a Python project portfolio with Git and GitHub is an important step toward demonstrating practical development skills. A strong portfolio combines useful applications, clean and maintainable code, clear documentation, automated testing, and a reliable version-control history.

Start with a manageable project, complete its core functionality, test it, document it, and publish it only after checking that the repository is safe to share. Then improve the project incrementally as you learn more Python, databases, APIs, testing, and deployment techniques.

For further learning, explore the Python Training Course at JustAcademy, visit the JustAcademy website, or register for a course demo.